import java.io.*;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;

/*
ID: egor2
LANG: JAVA
TASK:
 */

/**
 * @author Egor Kulikov (egor@egork.net)
 */
public class Border {
	@SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
	private final InputReader in;
	private final PrintWriter out;
	private final boolean testMode;

	private void solve() {
/*		int n = in.readInt();
		long[] a = new long[n];
		for (int i = 0; i < n; i++) a[i] = in.readLong();
    	Arrays.sort(a);
		long[] d = new long[n];
		d[n - 1] = a[n - 1];
		for (int i = n - 2; i >= 0; i--) {
			d[i] = a[i] - d[i + 1];
			if (a[i] > 3) {
				d[i] = Math.max(d[i], a[i] + d[i + 1] - 8);
			}
		}
		long res = d[0];
		long s = 0;
		for (long size : a) {
			s += size;
		}
		out.println(((s - res) / 2) + " " + ((s + res) / 2));
*/
		int a = in.readInt();
		int b = in.readInt();
		int c = in.readInt();
		int p = in.readInt();
		if (a > c) {
			int temp = a;
			a = c;
			c = temp;
		}
		if (b > c) {
			int temp = b;
			b = c;
			c = temp;
		}
		double s = getSquare(a, b, c);
		if (a + b + c == p) {
			out.printf("%.8f\n", s);
			return;
		}
		double left = a * b * c / (4 * s);
		if (p > left * 2 * Math.PI) {
			out.printf("%.8f\n", p * p / (4 * Math.PI));
			return;
		}
		if (c * c >= a * a + b * b && c * Math.PI < p) {
			out.printf("%.8f\n", p * p / (4 * Math.PI));
			return;
		}
		double right = 1e100;
		while (getAnswer(a, b, c, s, left) - getAnswer(a, b, c, s, right) > 1e-7) {
			double r = (left + right) / 2;
			if (!check(a, b, c, r, p))
				left = r;
			else
				right = r;
		}
		double r = (left + right) / 2;
		double answer = getAnswer(a, b, c, s, r);
		if (c * c > a * a + b * b) {
			left = c / 2.;
			right = a * b * c / (4 * s);
			boolean good = false;
			while (getSquare(c, left) - getSquare(c, right) > 1e-7) {
				r = (left + right) / 2;
				double sumAngles = 4 * Math.asin(c / (2 * r));
				if (sumAngles * r < p) {
					right = r;
					good = true;
				} else
					left = r;
			}
			r = (left + right) / 2;
			if (good)
				answer = Math.max(answer, 2 * getSquare(c, r));
		}
		out.printf("%.8f\n", answer);
	}

	private double getAnswer(int a, int b, int c, double s, double r) {
		return s + getSquare(a, r) + getSquare(b, r) + getSquare(c, r);
	}

	private boolean check(double a, double b, double c, double r, double p) {
		double sumAngles = 2 * (Math.asin(a / (2 * r)) + Math.asin(b / (2 * r)) + Math.asin(c / (2 * r)));
		return sumAngles * r < p;
	}

	private double getSquare(double a, double r) {
		double angle = 2 * Math.asin(a / (2 * r));
		double sina = a / (2 * r);
		double sin2a = 2 * sina * Math.sqrt(1 - sina * sina);
		return (angle - sin2a) * r * r / 2;
	}

	private double getSquare(double a, double b, double c) {
		double p = (a + b + c) / 2;
		return Math.sqrt(p * (p - a) * (p - b) * (p - c));
	}

	private static List<Test> createTests() {
		List<Test> tests = new ArrayList<Test>();
		tests.add(new Test("3 4 5 100", "795.774715459476679"));
		tests.add(new Test("3 4 5 12", "6.0"));
		tests.add(new Test("3 4 5 13", "12.261818799960896"));
		tests.add(new Test("3 5 3 16", "20.371832715762602978417121711682"));
		tests.add(new Test("3 5 3 15", "20.371832715762602978417121711682"));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
		return tests;
	}

	private void run() {
		//noinspection InfiniteLoopStatement
//		while (true)
//		int testCount = in.readInt();
//		for (int i = 0; i < testCount; i++)
		solve();
		exit();
	}

	private Border() {
		@SuppressWarnings({"UnusedDeclaration"})
		String id = getClass().getName().toLowerCase();
		//noinspection EmptyTryBlock
		try {
			System.setIn(new FileInputStream(id + ".in"));
			System.setOut(new PrintStream(new FileOutputStream(id + ".out")));
//			System.setIn(new FileInputStream("input.txt"));
//			System.setOut(new PrintStream(new FileOutputStream("output.txt")));
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		in = new StreamInputReader(System.in);
		out = new PrintWriter(System.out);
		testMode = false;
	}

	@SuppressWarnings({"UnusedParameters"})
	private static String check(String input, String result, String output) {
//		return strictCheck(result, output);
//		return tokenCheck(result, output);
		return isDoubleEquals(Double.parseDouble(result.trim().replace(',', '.')), Double.parseDouble(output.trim()), 1e-6) ? null : result.trim();
	}

	public static void main(String[] args) {
		if (args.length != 0 && args[0].equals("42"))
			test();
		else
			new Border().run();
	}

	private static void test() {
		List<Test> tests = createTests();
		int testCase = 0;
		for (Test test : tests) {
			System.out.print("Test #" + testCase + ": ");
			InputReader in = new StringInputReader(test.getInput());
			StringWriter out = new StringWriter(test.getOutput().length());
			long time = System.currentTimeMillis();
			try {
				new Border(in, new PrintWriter(out)).run();
			} catch (TestException e) {
				time = System.currentTimeMillis() - time;
				String checkResult = check(test.getInput(), out.getBuffer().toString(), test.getOutput());
				if (checkResult == null)
					System.out.print("OK");
				else
					System.out.print("WA (" + checkResult + ")");
				System.out.printf(" in %.3f s.\n", time / 1000.);
			} catch (Throwable e) {
				System.out.println("Exception thrown:");
				e.printStackTrace(System.out);
			}
			testCase++;
		}
		System.out.flush();
	}

	private static String tokenCheck(String result, String output) {
		StringInputReader resultStream = new StringInputReader(result);
		StringInputReader outputStream = new StringInputReader(output);
		int index = 0;
		boolean readingResult = false;
		try {
			while (true) {
				readingResult = true;
				String resultToken = resultStream.readString();
				readingResult = false;
				String outputToken = outputStream.readString();
				if (!resultToken.equals(outputToken))
					return "'" + outputToken + "' expected at " + index + " but '" + resultToken + "' received";
				index++;
			}
		} catch (InputMismatchException e) {
			if (readingResult) {
				try {
					outputStream.readString();
					return "only " + index + " tokens received";
				} catch (InputMismatchException e1) {
					return null;
				}
			} else
				return "only " + index + " tokens expected";
		}
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private static String strictCheck(String result, String output) {
		if (result.equals(output))
			return null;
		return "'" + output + "' expected but '" + result + "' received";
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private static boolean isDoubleEquals(double expected, double result, double certainty) {
		return Math.abs(expected - result) < certainty || Math.abs(expected - result) < certainty * expected;
	}

	private Border(InputReader in, PrintWriter out) {
		this.in = in;
		this.out = out;
		testMode = true;
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private void exit() {
		out.close();
		if (testMode)
			throw new TestException();
		System.exit(0);
	}

	private static class Test {
		private final String input;
		private final String output;

		private Test(String input, String output) {
			this.input = input;
			this.output = output;
		}

		public String getInput() {
			return input;
		}

		public String getOutput() {
			return output;
		}
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private abstract static class InputReader {
		public abstract int read();

		public int readInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long readLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuffer res = new StringBuffer();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private String readLine0() {
			StringBuffer buf = new StringBuffer();
			int c = read();
			while (c != '\n' && c != -1) {
				if (c != '\r')
					buf.appendCodePoint(c);
				c = read();
			}
			return buf.toString();
		}

		public String readLine() {
			String s = readLine0();
			while (s.trim().length() == 0)
				s = readLine0();
			return s;
		}

		public String readLine(boolean ignoreEmptyLines) {
			if (ignoreEmptyLines)
				return readLine();
			else
				return readLine0();
		}

		public BigInteger readBigInteger() {
			try {
				return new BigInteger(readString());
			} catch (NumberFormatException e) {
				throw new InputMismatchException();
			}
		}

		public char readCharacter() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			return (char) c;
		}

		public double readDouble() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, readInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, readInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public int[] readIntArray(int size) {
			int[] array = new int[size];
			for (int i = 0; i < size; i++)
				array[i] = readInt();
			return array;
		}

		public long[] readLongArray(int size) {
			long[] array = new long[size];
			for (int i = 0; i < size; i++)
				array[i] = readLong();
			return array;
		}

		public double[] readDoubleArray(int size) {
			double[] array = new double[size];
			for (int i = 0; i < size; i++)
				array[i] = readDouble();
			return array;
		}

		public String[] readStringArray(int size) {
			String[] array = new String[size];
			for (int i = 0; i < size; i++)
				array[i] = readString();
			return array;
		}

		public char[][] readTable(int rowCount, int columnCount) {
			char[][] table = new char[rowCount][columnCount];
			for (int i = 0; i < rowCount; i++) {
				for (int j = 0; j < columnCount; j++)
					table[i][j] = readCharacter();
			}
			return table;
		}

		public void readIntArrays(int[]... arrays) {
			for (int i = 0; i < arrays[0].length; i++) {
				for (int j = 0; j < arrays.length; j++)
					arrays[j][i] = readInt();
			}
		}
	}

	private static class StreamInputReader extends InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar, numChars;

		public StreamInputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
	}

	private static class StringInputReader extends InputReader {
		private Reader stream;
		private char[] buf = new char[1024];
		private int curChar, numChars;

		public StringInputReader(String stream) {
			this.stream = new StringReader(stream);
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
	}

	private static class TestException extends RuntimeException {}
}
